qcollect-traits 0.6.0

/// ### TODO
///
/// * impl other collections

use range::*;
use traits::*;

use std::borrow::Borrow;
use std::collections::Bound;

// ++++++++++++++++++++ Vec ++++++++++++++++++++
// TODO should we implement `[Push|Pop]Front`?

//use std::vec;
use std::slice;

impl<T> Len for Vec<T> {
    fn len(&self) -> usize { (**self).len() }
} 

impl<T> Capacity for Vec<T> {
    fn capacity(&self) -> usize { (*self).capacity() }
}

impl<T> Clear for Vec<T> {
    fn clear(&mut self){ (*self).clear() }
}

impl<T> ShrinkToFit for Vec<T> {
    fn shrink_to_fit(&mut self){ (*self).shrink_to_fit() }
}

impl<T> Reserve for Vec<T> {
    fn reserve(&mut self, n: usize){ (*self).reserve(n) }
    fn reserve_exact(&mut self, n: usize){ (*self).reserve_exact(n); }
}

/// TODO: add `Q: PartialEq<T>`-parameter?
impl<'q, T: PartialEq> Contains<&'q T> for Vec<T> {
    fn contains(&self, elt: &'q T) -> bool { (**self).contains(elt) }
}

impl<'a, T: 'a> _Get<'a, usize> for Vec<T> {
    type Ret = Option<&'a T>;
}

impl<T: 'static> Get<usize> for Vec<T> {
    fn get<'a>(&'a self, idx: usize) -> <Self as _Get<'a, usize>>::Ret { (**self).get(idx) }
}

impl<'a, T: 'a> _GetMut<'a, usize> for Vec<T> {
    type Ret = Option<&'a mut T>;
}

impl<T: 'static> GetMut<usize> for Vec<T> {
    fn get_mut<'a>(&'a mut self, idx: usize) -> <Self as _GetMut<'a, usize>>::Ret { (**self).get_mut(idx) } 
}

impl<'a, T: 'a, R> _Get<'a, R> for Vec<T> 
    where R: RangeArgument<usize>
{
    type Ret = &'a [T];
}

impl<T: 'static, R> Get<R> for Vec<T> 
    where R: RangeArgument<usize>
{
    fn get<'a>(&'a self, range: R) -> <Self as _Get<'a, R>>::Ret {
        Get::get(&**self, range)
    }
}

impl<'a, T: 'a, R> _GetMut<'a, R> for Vec<T> 
    where R: RangeArgument<usize>
{
    type Ret = &'a mut [T];
}

impl<T: 'static, R> GetMut<R> for Vec<T> 
    where R: RangeArgument<usize>
{
    fn get_mut<'a>(&'a mut self, range: R) -> <Self as _GetMut<'a, R>>::Ret {
        GetMut::get_mut(&mut**self, range)
    }
}

impl<'a, T: 'a> _Iterate<'a> for Vec<T> {
    type Iter = slice::Iter<'a, T>;
}

impl<T: 'static> Iterate for Vec<T> {
    fn iter<'a>(&'a self) -> <Self as _Iterate<'a>>::Iter { (**self).iter() }
}

impl<'a, T: 'a> _IterateMut<'a> for Vec<T> {
    type IterMut = slice::IterMut<'a, T>;
}

impl<T: 'static> IterateMut for Vec<T> {
    fn iter_mut<'a>(&'a mut self) -> <Self as _IterateMut<'a>>::IterMut { (**self).iter_mut() }
}

impl<T> Insert<(usize, T)> for Vec<T> {
    type Ret = ();
    fn insert(&mut self, pair: (usize, T)) -> Self::Ret { (*self).insert(pair.0, pair.1) }
}

impl<T> Insert2<usize, T> for Vec<T> {
    type Ret = ();
    fn insert(&mut self, idx: usize, val: T) -> Self::Ret { (*self).insert(idx, val) }
}

impl<T> Remove<usize> for Vec<T> {
    type Ret = T;
    fn remove(&mut self, idx: usize) -> Self::Ret { (*self).remove(idx) }
}

impl<T> PushBack<T> for Vec<T> {
    fn push_back(&mut self, val: T) { 
        (*self).push(val) 
    }
}

impl<T> PopBack for Vec<T> {
    type Val = T;
    fn pop_back(&mut self) -> Option<Self::Val> {
        (*self).pop()
    }
}

// ++++++++++++++++++++ BTreeMap ++++++++++++++++++++

use std::collections::btree_map::{self, BTreeMap};

impl<K: Ord, V> OrderedCollection for BTreeMap<K, V> {}

impl<K: Ord, V> Len for BTreeMap<K, V> {
    fn len(&self) -> usize { (*self).len() }
} 

impl<K: Ord, V> Clear for BTreeMap<K, V> {
    fn clear(&mut self){ (*self).clear() }
}

impl<'q, K, V, Q: ?Sized> Contains<&'q Q> for BTreeMap<K, V> 
    where K: Ord + Borrow<Q>, Q: Ord
{
    fn contains(&self, key: &'q Q) -> bool { (*self).contains_key(key) }
}

impl<'a, 'q, K, V: 'a, Q: ?Sized> _Get<'a, &'q Q> for BTreeMap<K, V> 
    where K: Ord + Borrow<Q>, Q: Ord
{
    type Ret = Option<&'a V>;
}

impl<'q, K, V: 'static, Q: ?Sized> Get<&'q Q> for BTreeMap<K, V> 
    where K: Ord + Borrow<Q>, Q: Ord
{
    fn get<'a>(&'a self, key: &'q Q) -> <Self as _Get<'a, &'q Q>>::Ret { (*self).get(key) }
}

impl<'a, 'q, K, V: 'a, Q: ?Sized> _GetMut<'a, &'q Q> for BTreeMap<K, V> 
    where K: Ord + Borrow<Q>, Q: Ord
{
    type Ret = Option<&'a mut V>;
}

impl<'q, K, V: 'static, Q: ?Sized> GetMut<&'q Q> for BTreeMap<K, V> 
    where K: Ord + Borrow<Q>, Q: Ord
{
    fn get_mut<'a>(&'a mut self, key: &'q Q) -> <Self as _GetMut<'a, &'q Q>>::Ret { (*self).get_mut(key) } 
}

/* TODO/FIXME
impl<'a, K: 'a, V: 'a, R> _Get<'a, R> for BTreeMap<K, V> 
    where K: Ord, R: RangeArgument<&'a K>
{
    type Ret = btree_map::Range<'a, K, V>;
}
*/

impl<'a, K: Ord + 'a, V: 'a> _Iterate<'a> for BTreeMap<K, V> {
    type Iter = btree_map::Iter<'a, K, V>;
}

impl<K: Ord + 'static, V: 'static> Iterate for BTreeMap<K, V> {
    fn iter<'a>(&'a self) -> <Self as _Iterate<'a>>::Iter { (*self).iter() }
}

impl<'a, K: Ord + 'a, V: 'a> _IterateMut<'a> for BTreeMap<K, V> {
    type IterMut = btree_map::IterMut<'a, K, V>;
}

impl<K: Ord + 'static, V: 'static> IterateMut for BTreeMap<K, V> {
    fn iter_mut<'a>(&'a mut self) -> <Self as _IterateMut<'a>>::IterMut { (*self).iter_mut() }
}

impl<K: Ord, V> Insert<(K, V)> for BTreeMap<K, V> {
    type Ret = Option<V>;
    fn insert(&mut self, pair: (K, V)) -> Self::Ret { (*self).insert(pair.0, pair.1) }
}

impl<K: Ord, V> Insert2<K, V> for BTreeMap<K, V> {
    type Ret = Option<V>;
    fn insert(&mut self, key: K, val: V) -> Self::Ret { (*self).insert(key, val) }
}

impl<'q, K, V, Q: ?Sized> Remove<&'q Q> for BTreeMap<K, V>
    where K: Ord + Borrow<Q>, Q: Ord
{
    type Ret = Option<V>;
    fn remove(&mut self, key: &'q Q) -> Self::Ret { (*self).remove(key) }
}

// ++++++++++++++++++++ BTreeSet ++++++++++++++++++++

use std::collections::btree_set::{self, BTreeSet};

impl<T: Ord> Len for BTreeSet<T> {
    fn len(&self) -> usize { (*self).len() }
} 

impl<T: Ord> Clear for BTreeSet<T> {
    fn clear(&mut self){ (*self).clear() }
}

impl<'q, T, Q: ?Sized> Contains<&'q Q> for BTreeSet<T> 
    where T: Ord + Borrow<Q>, Q: Ord
{
    fn contains(&self, elt: &'q Q) -> bool { (*self).contains(elt) }
}

impl<'a, T: Ord + 'a> _Iterate<'a> for BTreeSet<T> {
    type Iter = btree_set::Iter<'a, T>;
}

impl<T: Ord + 'static> Iterate for BTreeSet<T> {
    fn iter<'a>(&'a self) -> <Self as _Iterate<'a>>::Iter { (*self).iter() }
}

impl<T: Ord> Insert<T> for BTreeSet<T> {
    type Ret = bool;
    fn insert(&mut self, val: T) -> Self::Ret { (*self).insert(val) }
}

impl<'q, T, Q: ?Sized> Remove<&'q Q> for BTreeSet<T>
    where T: Ord + Borrow<Q>, Q: Ord
{
    type Ret = bool;
    fn remove(&mut self, val: &'q Q) -> Self::Ret { (*self).remove(val) }
}